package com.melody.controller;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.melody.entry.MusicInfo;
import com.melody.entry.PlaylistMusic;
import com.melody.entry.Result;
import com.melody.entry.PlaylistInfo;
import com.melody.model.vo.PlaylistInfoVo;
import com.melody.service.MusicInfoService;
import com.melody.service.PlaylistInfoService;
import com.melody.service.PlaylistMusicService;
import com.melody.utils.ThreadLocalUtil;
import io.swagger.models.auth.In;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

@RestController
@RequestMapping("/playlists")
public class PlaylistController {

    @Autowired
    private PlaylistInfoService playlistInfoService; // 注入播放列表信息服务层
    @Autowired
    private PlaylistMusicService playlistMusicService; // 注入播放列表音乐服务层
    @Autowired
    private MusicInfoService musicInfoService; // 注入音乐信息服务层

    /**
     * 创建歌单
     * @param playlistInfo
     * @return
     */
    @PostMapping("/create")
    public Result<PlaylistInfo> createPlaylist(@RequestBody PlaylistInfo playlistInfo) {
        Result<PlaylistInfo> result = playlistInfoService.createPlaylist(playlistInfo);
        if (result != null) {
            return Result.success(playlistInfo); // 返回创建成功的播放列表信息
        } else {
            return Result.error("服务器繁忙"); // 返回错误信息
        }
    }

    /**
     * 获取用户歌单列表
     * @param page
     * @param limit
     * @return
     */
    @GetMapping("/collect/playlist")
    public Result getPlaylists(@RequestParam Integer page,
                               @RequestParam Integer limit) {
        Map<String, Object> userInfo = ThreadLocalUtil.get(); // 获取当前用户信息
        Integer userId = (Integer) userInfo.get("userId"); // 获取用户ID
        List<PlaylistInfo> playlists = playlistInfoService.getPlaylistsByUserId(userId, page, limit); // 获取用户歌单
        if (playlists != null) {
            return Result.success(playlists); // 返回播放列表列表
        } else {
            return Result.error("暂无歌单"); // 返回错误信息
        }
    }

    /**
     * 更新歌单信息
     * @param playlistInfo
     * @return
     */
    @PutMapping(value = "/update/list_id")
    public Result updatePlaylistInfo(@RequestBody PlaylistInfo playlistInfo) {
        PlaylistInfo playlistInfoToUpdate = playlistInfoService.updatePlaylistInfo(playlistInfo);
        if (playlistInfoToUpdate != null) {
            return Result.success(playlistInfo); // 返回更新成功的播放列表信息
        } else {
            return Result.error("服务器繁忙，修改失败"); // 返回错误信息
        }
    }

    /**
     * 向歌单中添加歌曲
     * @param playlistMusic
     * @return
     */
    @PostMapping("/list_id/add_music")
    public Result addMusicToPlaylist(@RequestBody PlaylistMusic playlistMusic) {
        PlaylistMusic playlistMusic2 = playlistMusicService.addMusicToPlaylist(playlistMusic);
        if (playlistMusic2 != null) {
            return Result.success(playlistMusic); // 返回添加成功的音乐信息
        } else {
            return Result.error("服务器繁忙，添加失败"); // 返回错误信息
        }
    }

    /**
     *  批量向歌单中添加歌曲
     * @param Ids
     * @param listId
     * @return
     */
    @PostMapping("/list_id/add_music_batch")
    public Result batchAddMusicToPlaylist(@RequestParam List<Integer> Ids, Integer listId) {
        int addcount = playlistMusicService.batchAddMusicToPlaylist(Ids, listId);
        if (addcount > 0) {
            return Result.success("添加数据" + addcount + "条"); // 返回批量添加成功的信息条数
        } else {
            return Result.error("服务器繁忙，添加失败"); // 返回错误信息
        }
    }

    /**
     * 从播放列表删除音乐
     * @param Id
     * @param listId
     * @return
     */
    @DeleteMapping(value = "/list_id/delete_music")
    public Result deleteMusicFromPlaylist(@RequestParam Long Id, Long listId) {
        PlaylistMusic playlistMusic2 = playlistMusicService.deleteMusicFromPlaylist(Id, listId);
        if (playlistMusic2 != null) {
            return Result.success(playlistMusic2); // 返回删除成功的音乐信息
        } else {
            return Result.error("服务器繁忙，删除失败"); // 返回错误信息
        }
    }

    /**
     * 批量从播放列表删除音乐
     * @param Ids
     * @param listId
     * @return
     */
    @DeleteMapping(value = "/list_id/batch_delete_music")
    public Result batchDeleteMusicFromPlaylist(@RequestParam List<Long> Ids, Long listId) {
        List<PlaylistMusic> playlistMusic2 = playlistMusicService.batchDeleteMusicFromPlaylist(Ids, listId);
        if (playlistMusic2 != null) {
            return Result.success(playlistMusic2); // 返回批量删除成功的音乐列表
        } else {
            return Result.error("服务器繁忙，删除失败"); // 返回错误信息
        }
    }

    /**
     * 删除播放列表
     * @param listId
     * @return
     */
    @DeleteMapping(value = "/delete/list_id")
    public Result deletePlaylist(@RequestParam Long listId) {
        playlistMusicService.batchDeleteMusicFromPlaylist2(listId); // 批量删除播放列表中的所有音乐
        PlaylistInfo playlistInfo2 = playlistInfoService.deletePlaylistInfo(listId); // 删除播放列表信息
        if (playlistInfo2 != null) {
            return Result.success(playlistInfo2); // 返回删除成功的播放列表信息
        } else {
            return Result.error("服务器繁忙，删除失败"); // 返回错误信息
        }
    }

    /**
     * 获取播放列表详情
     * @param listId
     * @return
     */
    @GetMapping("/details")
    public Result getPlaylistDetails(@RequestParam Long listId) {
        PlaylistInfo playlistInfo = playlistInfoService.getPlaylistDetails(listId); // 获取播放列表详情
        if (playlistInfo != null) {
            return Result.success(playlistInfo); // 返回播放列表详情
        } else {
            return Result.error("服务器繁忙，查询失败"); // 返回错误信息
        }
    }

    /**
     * 根据歌单ID获取音乐列表
     * @param listId
     * @param limit
     * @return
     */
    @GetMapping("/music")
    public Result getMusicByListId(@RequestParam Integer listId,
                                   @RequestParam(defaultValue = "10") Integer limit) {
        List<Integer> musicids = playlistMusicService.getMusicsListId(listId, limit); // 获取播放列表中的music_id列表
        List<MusicInfo> musicInfos = musicInfoService.getMusicsByListId(musicids); // 获取音乐信息列表
        if (musicInfos != null && !musicInfos.isEmpty()) {
            return Result.success(musicInfos); // 返回音乐信息列表
        } else {
            return Result.error("未找到歌单或歌单ID无效"); // 返回错误信息
        }
    }

    /**
     * 根据标签ID获取播放列表
     * @param labelId
     * @param limit
     * @return
     */
    @GetMapping("/label")
    public Result getPlaylistsByLabel(@RequestParam Integer labelId,
                                      @RequestParam(defaultValue = "10") Integer limit) {
        List<PlaylistInfo> playlists = playlistInfoService.getPlaylistsByLabelId(labelId, limit); // 获取播放列表列表
        if (playlists != null && !playlists.isEmpty()) {
            return Result.success(playlists); // 返回播放列表列表
        } else {
            return Result.error("未找到歌单或歌单ID无效"); // 返回错误信息
        }
    }



    // 其他歌单相关接口...

    /**
     * 根据id获得歌单详情
     */
    @GetMapping("/songListInfoById")
    public Result<PlaylistInfoVo> getSongListInfoById(@RequestParam Integer listId) {
       return  Result.success( playlistInfoService.getSongListInfoById(listId));
    }

    // 定义一个GET请求的接口，用于分页获取随机歌单信息
    @GetMapping("/pagination")
    public Result getRandomPlaylistInfo(
            // 从请求参数中获取当前页码，默认值为1
            @RequestParam(defaultValue = "1") Integer page,
            // 从请求参数中获取每页显示的数量，默认值为10
            @RequestParam(defaultValue = "10") Integer limit) {
        // 调用服务层方法，根据页码和每页数量获取随机歌单信息
        List<PlaylistInfo> playlists = playlistInfoService.getRandomPlaylistInfo(page, limit);
        // 判断返回的歌单列表是否为空
        if (playlists != null && !playlists.isEmpty()) {
            // 如果不为空，返回成功的结果，包含歌单列表
            return Result.success(playlists);
        } else {
            // 如果为空，返回错误信息
            return Result.error("未找到歌单");
        }
    }

    // 定义一个GET请求的接口，用于获取指定数量的随机歌单信息
    @GetMapping("/randoms")
    public Result getRandomPlaylistInfos(
            // 从请求参数中获取需要获取的歌单数量，默认值为5
            @RequestParam(defaultValue = "8") Integer limit) {
        // 调用服务层方法，根据指定数量获取随机歌单信息
        List<PlaylistInfo> playlists = playlistInfoService.getRandomPlaylistInfos(limit);
        // 判断返回的歌单列表是否为空
        if (playlists != null && !playlists.isEmpty()) {
            // 如果不为空，返回成功的结果，包含歌单列表
            return Result.success(playlists);
        } else {
            // 如果为空，返回错误信息
            return Result.error("未找到歌单");
        }
    }



//    /**
//     * 获取推荐歌单信息表示
//     * @param
//     * @return
//     */
//    @GetMapping("/recommendSongs")
//    public Result<IPage<PlaylistInfo>> getRecommendSongs(@RequestBody ){
//        return Result.success();
//    }

    /**
     * 根据歌单类型查询歌单
     * @param labelId
     * @param pageNum
     * @param pageSize
     * @return List<PlaylistInfo>
     */
    @GetMapping("/playListType")
    public Result<List<PlaylistInfo>> getPlaylistListByLabelId(@RequestParam Integer labelId, Integer pageNum, Integer pageSize) {
        List<PlaylistInfo> playlists = playlistInfoService.getPlaylistListByLabelId(labelId, pageNum, pageSize);
        if (playlists != null && !playlists.isEmpty()) {
            return Result.success(playlists);
        } else {
            return Result.error("未找到歌单");
        }
    }


}